/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
/**
 * @author Denis M. Kishenko
 * @version $Revision$
 */

package org.medcare.Dicom;

import java.io.Serializable;

/**
 * The Rectangle class defines the rectangular area in terms of its upper left
 * corner coordinates [x,y], its width, and its height. A Rectangle specified by
 * [x, y, width, height] parameters has an outline path with corners at [x, y],
 * [x + width,y], [x + width,y + height], and [x, y + height]. <br>
 * <br>
 * The rectangle is empty if the width or height is negative or zero. In this
 * case the isEmpty method returns true.
 * 
 * @since Android 1.0
 */
public class Rectangle implements Serializable {

	/**
	 * The Constant serialVersionUID.
	 */
	private static final long serialVersionUID = -4345857070255674764L;

	/**
	 * The X coordinate of the rectangle's left upper corner.
	 */
	public int x;

	/**
	 * The Y coordinate of the rectangle's left upper corner.
	 */
	public int y;

	/**
	 * The width of rectangle.
	 */
	public int width;

	/**
	 * The height of rectangle.
	 */
	public int height;

	/**
	 * Instantiates a new rectangle with [0, 0] upper left corner coordinates,
	 * the width and the height are zero.
	 */
	public Rectangle() {
		setBounds(0, 0, 0, 0);
	}

	/**
	 * Instantiates a new rectangle whose upper left corner coordinates are
	 * given by the Point object (p.X and p.Y), and the width and the height are
	 * zero.
	 * 
	 * @param p
	 *            the Point specifies the upper left corner coordinates of the
	 *            rectangle.
	 */
	public Rectangle(Point p) {
		setBounds(p.x, p.y, 0, 0);
	}

	/**
	 * Instantiates a new rectangle whose upper left corner coordinates are
	 * given by the Point object (p.X and p.Y), and the width and the height are
	 * given by Dimension object (d.width and d.height).
	 * 
	 * @param p
	 *            the point specifies the upper left corner coordinates of the
	 *            rectangle.
	 * @param d
	 *            the dimension specifies the width and the height of the
	 *            rectangle.
	 */
	/*
	 * public Rectangle(Point p, Dimension d) { setBounds(p.x, p.y, d.width,
	 * d.height); }
	 */

	/**
	 * Instantiates a new rectangle determined by the upper left corner
	 * coordinates (x, y), width and height.
	 * 
	 * @param x
	 *            the X upper left corner coordinate of the rectangle.
	 * @param y
	 *            the Y upper left corner coordinate of the rectangle.
	 * @param width
	 *            the width of rectangle.
	 * @param height
	 *            the height of rectangle.
	 */
	public Rectangle(int x, int y, int width, int height) {
		setBounds(x, y, width, height);
	}

	/**
	 * Instantiates a new rectangle with [0, 0] as its upper left corner
	 * coordinates and the specified width and height.
	 * 
	 * @param width
	 *            the width of rectangle.
	 * @param height
	 *            the height of rectangle.
	 */
	public Rectangle(int width, int height) {
		setBounds(0, 0, width, height);
	}

	/**
	 * Instantiates a new rectangle with the same coordinates as the given
	 * source rectangle.
	 * 
	 * @param rows
	 *            the Rectangle object which parameters will be used for
	 *            instantiating a new Rectangle.
	 */
	public Rectangle(Rectangle r) {
		setBounds(r.x, r.y, r.width, r.height);
	}

	/*
	 * public Rectangle(Dimension d) { setBounds(0, 0, d.width, d.height); }
	 */
	/**
	 * Gets the X coordinate of bound as a double.
	 * 
	 * @return the X coordinate of bound as a double.
	 * @see java.awt.geom.RectangularShape#getX()
	 */
	public double getX() {
		return x;
	}

	/**
	 * Gets the Y coordinate of bound as a double.
	 * 
	 * @return the Y coordinate of bound as a double.
	 * @see java.awt.geom.RectangularShape#getY()
	 */
	public double getY() {
		return y;
	}

	/**
	 * Gets the height of the rectangle as a double.
	 * 
	 * @return the height of the rectangle as a double.
	 * @see java.awt.geom.RectangularShape#getHeight()
	 */
	public double getHeight() {
		return height;
	}

	/**
	 * Gets the width of the rectangle as a double.
	 * 
	 * @return the width of the rectangle as a double.
	 * @see java.awt.geom.RectangularShape#getWidth()
	 */
	public double getWidth() {
		return width;
	}

	/**
	 * Determines whether or not the rectangle is empty. The rectangle is empty
	 * if its width or height is negative or zero.
	 * 
	 * @return true, if the rectangle is empty, otherwise false.
	 * @see java.awt.geom.RectangularShape#isEmpty()
	 */
	public boolean isEmpty() {
		return width <= 0 || height <= 0;
	}

	/**
	 * Gets the size of a Rectangle as Dimension object.
	 * 
	 * @return a Dimension object which represents size of the rectangle.
	 */
	/*
	 * public Dimension getSize() { return new Dimension(width, height); }
	 */

	/**
	 * Sets the size of the Rectangle.
	 * 
	 * @param width
	 *            the new width of the rectangle.
	 * @param height
	 *            the new height of the rectangle.
	 */
	public void setSize(int width, int height) {
		this.width = width;
		this.height = height;
	}

	/**
	 * Sets the size of a Rectangle specified as Dimension object.
	 * 
	 * @param d
	 *            a Dimension object which represents new size of a rectangle.
	 */
	/*
	 * public void setSize(Dimension d) { setSize(d.width, d.height); }
	 */

	/**
	 * Gets the location of a rectangle's upper left corner as a Point object.
	 * 
	 * @return the Point object with coordinates equal to the upper left corner
	 *         of the rectangle.
	 */
	public Point getLocation() {
		return new Point(x, y);
	}

	/**
	 * Sets the location of the rectangle in terms of its upper left corner
	 * coordinates X and Y.
	 * 
	 * @param x
	 *            the X coordinate of the rectangle's upper left corner.
	 * @param y
	 *            the Y coordinate of the rectangle's upper left corner.
	 */
	public void setLocation(int x, int y) {
		this.x = x;
		this.y = y;
	}

	/**
	 * Sets the location of a rectangle using a Point object to give the
	 * coordinates of the upper left corner.
	 * 
	 * @param p
	 *            the Point object which represents the new upper left corner
	 *            coordinates of rectangle.
	 */
	public void setLocation(Point p) {
		setLocation(p.x, p.y);
	}

	/**
	 * Moves a rectangle to the new location by moving its upper left corner to
	 * the point with coordinates X and Y.
	 * 
	 * @param x
	 *            the new X coordinate of the rectangle's upper left corner.
	 * @param y
	 *            the new Y coordinate of the rectangle's upper left corner.
	 * @deprecated Use setLocation(int, int) method.
	 */
	@Deprecated
	public void move(int x, int y) {
		setLocation(x, y);
	}

	/**
	 * Sets the rectangle to be the nearest rectangle with integer coordinates
	 * bounding the rectangle defined by the double-valued parameters.
	 * 
	 * @param x
	 *            the X coordinate of the upper left corner of the double-valued
	 *            rectangle to be bounded.
	 * @param y
	 *            the Y coordinate of the upper left corner of the double-valued
	 *            rectangle to be bounded.
	 * @param width
	 *            the width of the rectangle to be bounded.
	 * @param height
	 *            the height of the rectangle to be bounded.
	 * @see java.awt.geom.Rectangle2D#setRect(double, double, double, double)
	 */
	public void setRect(double x, double y, double width, double height) {
		int x1 = (int) Math.floor(x);
		int y1 = (int) Math.floor(y);
		int x2 = (int) Math.ceil(x + width);
		int y2 = (int) Math.ceil(y + height);
		setBounds(x1, y1, x2 - x1, y2 - y1);
	}

	/**
	 * Sets a new size for the rectangle.
	 * 
	 * @param width
	 *            the rectangle's new width.
	 * @param height
	 *            the rectangle's new height.
	 * @deprecated use the setSize(int, int) method.
	 */
	@Deprecated
	public void resize(int width, int height) {
		setBounds(x, y, width, height);
	}

	/**
	 * Resets the bounds of a rectangle to the specified x, y, width and height
	 * parameters.
	 * 
	 * @param x
	 *            the new X coordinate of the upper left corner.
	 * @param y
	 *            the new Y coordinate of the upper left corner.
	 * @param width
	 *            the new width of rectangle.
	 * @param height
	 *            the new height of rectangle.
	 * @deprecated use setBounds(int, int, int, int) method
	 */
	@Deprecated
	public void reshape(int x, int y, int width, int height) {
		setBounds(x, y, width, height);
	}

	/**
	 * Gets bounds of the rectangle as a new Rectangle object.
	 * 
	 * @return the Rectangle object with the same bounds as the original
	 *         rectangle.
	 * @see java.awt.geom.RectangularShape#getBounds()
	 */
	public Rectangle getBounds() {
		return new Rectangle(x, y, width, height);
	}

	/**
	 * Sets the bounds of a rectangle to the specified x, y, width, and height
	 * parameters.
	 * 
	 * @param x
	 *            the X coordinate of the upper left corner.
	 * @param y
	 *            the Y coordinate of the upper left corner.
	 * @param width
	 *            the width of rectangle.
	 * @param height
	 *            the height of rectangle.
	 */
	public void setBounds(int x, int y, int width, int height) {
		this.x = x;
		this.y = y;
		this.height = height;
		this.width = width;
	}

	/**
	 * Sets the bounds of the rectangle to match the bounds of the Rectangle
	 * object sent as a parameter.
	 * 
	 * @param rows
	 *            the Rectangle object which specifies the new bounds.
	 */
	public void setBounds(Rectangle r) {
		setBounds(r.x, r.y, r.width, r.height);
	}

	/**
	 * Enlarges the rectangle by moving each corner outward from the center by a
	 * distance of dx horizonally and a distance of dy vertically. Specifically,
	 * changes a rectangle with [x, y, width, height] parameters to a rectangle
	 * with [x-dx, y-dy, width+2*dx, height+2*dy] parameters.
	 * 
	 * @param dx
	 *            the horizontal distance to move each corner coordinate.
	 * @param dy
	 *            the vertical distance to move each corner coordinate.
	 */
	public void grow(int dx, int dy) {
		x -= dx;
		y -= dy;
		width += dx + dx;
		height += dy + dy;
	}

	/**
	 * Moves a rectangle a distance of mx along the x coordinate axis and a
	 * distance of my along y coordinate axis.
	 * 
	 * @param mx
	 *            the horizontal translation increment.
	 * @param my
	 *            the vertical translation increment.
	 */
	public void translate(int mx, int my) {
		x += mx;
		y += my;
	}

	/**
	 * Enlarges the rectangle to cover the specified point.
	 * 
	 * @param px
	 *            the X coordinate of the new point to be covered by the
	 *            rectangle.
	 * @param py
	 *            the Y coordinate of the new point to be covered by the
	 *            rectangle.
	 */
	public void add(int px, int py) {
		int x1 = Math.min(x, px);
		int x2 = Math.max(x + width, px);
		int y1 = Math.min(y, py);
		int y2 = Math.max(y + height, py);
		setBounds(x1, y1, x2 - x1, y2 - y1);
	}

	/**
	 * Enlarges the rectangle to cover the specified point with the new point
	 * given as a Point object.
	 * 
	 * @param p
	 *            the Point object that specifies the new point to be covered by
	 *            the rectangle.
	 */
	public void add(Point p) {
		add(p.x, p.y);
	}

	/**
	 * Adds a new rectangle to the original rectangle, the result is an union of
	 * the specified specified rectangle and original rectangle.
	 * 
	 * @param rows
	 *            the Rectangle which is added to the original rectangle.
	 */
	public void add(Rectangle r) {
		int x1 = Math.min(x, r.x);
		int x2 = Math.max(x + width, r.x + r.width);
		int y1 = Math.min(y, r.y);
		int y2 = Math.max(y + height, r.y + r.height);
		setBounds(x1, y1, x2 - x1, y2 - y1);
	}

	/**
	 * Determines whether or not the point with specified coordinates [px, py]
	 * is within the bounds of the rectangle.
	 * 
	 * @param px
	 *            the X coordinate of point.
	 * @param py
	 *            the Y coordinate of point.
	 * @return true, if the point with specified coordinates [px, py] is within
	 *         the bounds of the rectangle, false otherwise.
	 */
	public boolean contains(int px, int py) {
		if (isEmpty()) {
			return false;
		}
		if (px < x || py < y) {
			return false;
		}
		px -= x;
		py -= y;
		return px < width && py < height;
	}

	/**
	 * Determines whether or not the point given as a Point object is within the
	 * bounds of the rectangle.
	 * 
	 * @param p
	 *            the Point object
	 * @return true, if the point p is within the bounds of the rectangle,
	 *         otherwise false.
	 */
	public boolean contains(Point p) {
		return contains(p.x, p.y);
	}

	/**
	 * Determines whether or not the rectangle specified by [rx, ry, rw, rh]
	 * parameters is located inside the original rectangle.
	 * 
	 * @param rx
	 *            the X coordinate of the rectangle to compare.
	 * @param ry
	 *            the Y coordinate of the rectangle to compare.
	 * @param rw
	 *            the width of the rectangle to compare.
	 * @param rh
	 *            the height of the rectangle to compare.
	 * @return true, if a rectangle with [rx, ry, rw, rh] parameters is entirely
	 *         contained in the original rectangle, false otherwise.
	 */
	public boolean contains(int rx, int ry, int rw, int rh) {
		return contains(rx, ry) && contains(rx + rw - 1, ry + rh - 1);
	}

	/**
	 * Compares whether or not the rectangle specified by the Rectangle object
	 * is located inside the original rectangle.
	 * 
	 * @param rows
	 *            the Rectangle object.
	 * @return true, if the rectangle specified by Rectangle object is entirely
	 *         contained in the original rectangle, false otherwise.
	 */
	public boolean contains(Rectangle r) {
		return contains(r.x, r.y, r.width, r.height);
	}

	/**
	 * Compares whether or not a point with specified coordinates [px, py]
	 * belongs to a rectangle.
	 * 
	 * @param px
	 *            the X coordinate of a point.
	 * @param py
	 *            the Y coordinate of a point.
	 * @return true, if a point with specified coordinates [px, py] belongs to a
	 *         rectangle, otherwise false.
	 * @deprecated use contains(int, int) method.
	 */
	@Deprecated
	public boolean inside(int px, int py) {
		return contains(px, py);
	}

	/**
	 * Returns the intersection of the original rectangle with the specified
	 * rectangle. An empty rectangle is returned if there is no intersection.
	 * 
	 * @param rows
	 *            the Rectangle object.
	 * @return the Rectangle object is result of the original rectangle with the
	 *         specified rectangle.
	 */
	public Rectangle intersection(Rectangle r) {
		int x1 = Math.max(x, r.x);
		int y1 = Math.max(y, r.y);
		int x2 = Math.min(x + width, r.x + r.width);
		int y2 = Math.min(y + height, r.y + r.height);
		return new Rectangle(x1, y1, x2 - x1, y2 - y1);
	}

	/**
	 * Determines whether or not the original rectangle intersects the specified
	 * rectangle.
	 * 
	 * @param rows
	 *            the Rectangle object.
	 * @return true, if the two rectangles overlap, false otherwise.
	 */
	public boolean intersects(Rectangle r) {
		return !intersection(r).isEmpty();
	}

	/**
	 * Determines where the specified Point is located with respect to the
	 * rectangle. This method computes whether the point is to the right or to
	 * the left of the rectangle and whether it is above or below the rectangle,
	 * and packs the result into an integer by using a binary OR operation with
	 * the following masks:
	 * <ul>
	 *<li>Rectangle2D.OUT_LEFT</li>
	 *<li>Rectangle2D.OUT_TOP</li>
	 *<li>Rectangle2D.OUT_RIGHT</li>
	 *<li>Rectangle2D.OUT_BOTTOM</li>
	 *</ul>
	 * If the rectangle is empty, all masks are set, and if the point is inside
	 * the rectangle, none are set.
	 * 
	 * @param px
	 *            the X coordinate of the specified point.
	 * @param py
	 *            the Y coordinate of the specified point.
	 * @return the location of the Point relative to the rectangle as the result
	 *         of logical OR operation with all out masks.
	 * @see java.awt.geom.Rectangle2D#outcode(double, double)
	 */
	/*
	 * @Override public int outcode(double px, double py) { int code = 0;
	 * 
	 * if (width <= 0) { code |= OUT_LEFT | OUT_RIGHT; } else if (px < x) { code
	 * |= OUT_LEFT; } else if (px > x + width) { code |= OUT_RIGHT; }
	 * 
	 * if (height <= 0) { code |= OUT_TOP | OUT_BOTTOM; } else if (py < y) {
	 * code |= OUT_TOP; } else if (py > y + height) { code |= OUT_BOTTOM; }
	 * 
	 * return code; }
	 */

	/**
	 * Enlarges the rectangle to cover the specified rectangle.
	 * 
	 * @param rows
	 *            the Rectangle.
	 * @return the union of the original and the specified rectangle.
	 */
	public Rectangle union(Rectangle r) {
		Rectangle dst = new Rectangle(this);
		dst.add(r);
		return dst;
	}

	/**
	 * Compares the original Rectangle with the specified object.
	 * 
	 * @param obj
	 *            the specified Object for comparison.
	 * @return true, if the specified Object is a rectangle with the same
	 *         dimensions as the original rectangle, false otherwise.
	 * @see java.awt.geom.Rectangle2D#equals(Object)
	 */
	@Override
	public boolean equals(Object obj) {
		if (obj == this) {
			return true;
		}
		if (obj instanceof Rectangle) {
			Rectangle r = (Rectangle) obj;
			return r.x == x && r.y == y && r.width == width
					&& r.height == height;
		}
		return false;
	}

	/**
	 * Returns a string representation of the rectangle; the string contains [x,
	 * y, width, height] parameters of the rectangle.
	 * 
	 * @return the string representation of the rectangle.
	 */
	@Override
	public String toString() {
		// The output format based on 1.5 release behaviour. It could be
		// obtained in the following way
		// System.out.println(new Rectangle().toString())
		return getClass().getName() + "[x=" + x + ",y=" + y + //$NON-NLS-1$ //$NON-NLS-2$
				",width=" + width + ",height=" + height + "]"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
	}

}
